package com.kt.learn1

/**
 * Kotlin 函数示例
 * 包括函数声明、参数、返回值、默认参数、可变参数、高阶函数等
 */

fun main() {
    // 基本函数
    chapter1BasicFunctions()

    // 参数和返回值
    chapter2ParametersAndReturnValues()

    // 默认参数
    chapter3DefaultParameters()

    // 可变参数
    chapter4VariableParameters()

    // 高阶函数
    chapter5HigherOrderFunctions()

    // 扩展函数
    chapter6ExtensionFunctions()

    // 本地函数
    chapter7LocalFunctions()
}

// 基本函数
fun chapter1BasicFunctions() {
    println("\n===== 基本函数 =====")

    // 声明一个简单的函数
    fun greet(name: String) {
        println("Hello, $name!")
    }

    greet("Alice") // 输出：Hello, Alice!
}

// 参数和返回值
fun chapter2ParametersAndReturnValues() {
    println("\n===== 参数和返回值 =====")

    // 声明一个带有参数和返回值的函数
    fun add(a: Int, b: Int): Int {
        return a + b
    }

    println("10 + 5 = ${add(10, 5)}") // 输出：10 + 5 = 15

    // 单表达式函数（可以省略大括号和 return 关键字）
    fun subtract(a: Int, b: Int) = a - b

    println("10 - 5 = ${subtract(10, 5)}") // 输出：10 - 5 = 5
}

// 默认参数
fun chapter3DefaultParameters() {
    println("\n===== 默认参数 =====")

    // 声明一个带有默认参数值的函数
    fun greet(name: String = "Guest") {
        println("Hello, $name!")
    }

    greet("Alice") // 输出：Hello, Alice!
    greet() // 输出：Hello, Guest!
}

// 可变参数
fun chapter4VariableParameters() {
    println("\n===== 可变参数 =====")

    // 声明一个带有可变参数的函数
    fun sum(vararg numbers: Int): Int {
        return numbers.sum()
    }

    println("Sum: ${sum(1, 2, 3, 4, 5)}") // 输出：Sum: 15
}

// 高阶函数
fun chapter5HigherOrderFunctions() {
    println("\n===== 高阶函数 =====")

    // 声明一个高阶函数，接受一个函数作为参数
    fun calculate(operation: (Int, Int) -> Int, a: Int, b: Int): Int {
        return operation(a, b)
    }

    // 定义一个 lambda 表达式作为参数传递
    println("Multiplication: ${calculate({ a, b -> a * b }, 5, 3)}") // 输出：Multiplication: 15

    // 声明一个返回函数的高阶函数
    fun getOperation(operator: String): (Int, Int) -> Int {
        return when (operator) {
            "+" -> { a, b -> a + b }
            "-" -> { a, b -> a - b }
            "*" -> { a, b -> a * b }
            "/" -> { a, b -> a / b }
            else -> throw IllegalArgumentException("Invalid operator")
        }
    }

    val addOperation = getOperation("+")
    println("Addition: ${addOperation(10, 5)}") // 输出：Addition: 15
}

// 扩展函数
fun chapter6ExtensionFunctions() {
    println("\n===== 扩展函数 =====")

    // 声明一个字符串的扩展函数
    fun String.repeatTimes(times: Int): String {
        return this.repeat(times)
    }

    println("Kotlin".repeatTimes(3)) // 输出：KotlinKotlinKotlin
}

// 本地函数
fun chapter7LocalFunctions() {
    println("\n===== 本地函数 =====")

    fun calculateSum(numbers: List<Int>): Int {
        // 本地函数
        fun sum(acc: Int, num: Int): Int {
            return acc + num
        }

        return numbers.fold(0, ::sum)
    }

    val numbers = listOf(1, 2, 3, 4, 5)
    println("Sum: ${calculateSum(numbers)}") // 输出：Sum: 15
}